home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / graph3D / graph3D source / g3D_DataFile.c < prev    next >
Text File  |  1993-09-17  |  3KB  |  213 lines
  1. /*
  2.     Copyright '89    Christopher Moll
  3.     all rights reserved
  4. */
  5.  
  6.  
  7. #include    "graph3D.h"
  8. #ifdef    _LSC3_
  9. #    include    <FileMgr.h>
  10. #    include    <EventMgr.h>
  11. #    include    <StdFilePkg.h>
  12. #endif
  13.  
  14.  
  15. extern    int        numX, numY;
  16.  
  17. extern    Real    startX, startY;
  18. extern    Real    endX, endY;
  19. extern    Real    deltaX, deltaY;
  20. extern    int        numX, numY;
  21.  
  22. extern    Vector        maxVect, minVect;
  23.  
  24. extern    Real        *funcResults;
  25. extern    Point        *graphPoints;    /* same elements as funcResults */
  26.  
  27. extern    Boolean        vectrsCurrent;
  28.  
  29. int        ReadLine(...);
  30.  
  31.  
  32. Boolean
  33. ReadData()
  34. {
  35. unsigned    char    rdBuffer[256], *inLine;
  36.     int        theErr;
  37.     int        ReadLine();
  38.     Real    atof();
  39.     Boolean        DoGetFile(), AllocatePts();
  40.  
  41.     if (NOT(DoGetFile()))
  42.         return(FALSE);
  43.  
  44.     theErr = ReadLine(256, rdBuffer);
  45.     if (theErr) {
  46.         NumToString((long)theErr, rdBuffer);
  47.         ParamText(rdBuffer, "\0", "\0", "\0");
  48.         Alert(ALRT_FILE, NIL);
  49.         return;
  50.     }
  51.  
  52.     inLine = rdBuffer;
  53.     
  54.     numX = atof(inLine);
  55.     while(NOT(isspace(*inLine)))
  56.         ++inLine;
  57.     while(isspace(*inLine))
  58.         ++inLine;
  59.     numY = atof(inLine);
  60.     startX = 0.0;
  61.     startY = 0.0;
  62.     endX = numX;
  63.     endY = numY;
  64.  
  65.     deltaX = 1.0;
  66.     deltaY = 1.0;
  67.  
  68.     if (NOT(AllocatePts()))
  69.     {
  70.         MemAlert();
  71.         return;
  72.     }
  73.  
  74.     StoreDataPts();
  75.     CloseFile();
  76.  
  77.     vectrsCurrent = FALSE;
  78.     return(TRUE);
  79. }
  80.  
  81. static
  82. Boolean
  83. DoGetFile()
  84. {
  85. static    Point    where = {100, 100};
  86.     long        theList[4];
  87.     SFReply        theReply;
  88.     
  89.     theList[0] = 'TEXT';
  90.     
  91.     SFGetFile(where, "", NIL, 1, theList, NIL, &theReply);
  92.     
  93.     SetVol(NIL, theReply.vRefNum);
  94.     OpenFile(theReply.fName);
  95.     return(theReply.good);
  96. }
  97.  
  98. static    IOParam        dataFile;
  99.  
  100. static
  101. OpenFile(fileName)
  102. unsigned    char    *fileName;
  103. {
  104.     dataFile.ioCompletion = NIL;
  105.     dataFile.ioNamePtr = fileName;
  106.     dataFile.ioVRefNum = 0;
  107.     dataFile.ioPermssn = fsRdPerm;
  108.  
  109.     PBOpen(&dataFile, FALSE);
  110. }
  111.  
  112. static
  113. CloseFile()
  114. {
  115.     PBClose(&dataFile, FALSE);
  116. }
  117.  
  118. #define        newLnStop    0x80
  119.  
  120.  
  121. static
  122. int
  123. ReadLine(maxRead, rdBuffer)
  124. int    maxRead;
  125. char    *rdBuffer;
  126. {
  127.     dataFile.ioBuffer = rdBuffer;
  128.     dataFile.ioReqCount = maxRead;
  129.     dataFile.ioPosMode = fsAtMark + newLnStop + ('\r' << 8);
  130.  
  131.     PBRead(&dataFile, FALSE);
  132.     rdBuffer[dataFile.ioActCount - 1] = '\0';
  133.     return(dataFile.ioResult);
  134. }
  135.  
  136. #define    LN_LEN    1000
  137.  
  138. static
  139. StoreDataPts()
  140. {
  141.     register    int    xCnt, yCnt;
  142.     Real        currX, currY;
  143.     Real        maxFunc, minFunc, funcVal;
  144.     Real        xAtMax, yAtMax;
  145.     Real        xAtMin, yAtMin;
  146.     unsigned    char    rdBuffer[LN_LEN], *inLine;
  147.     int            theErr;
  148.     Real        atof(), NextVal();
  149.     Boolean        CmndPeriod();
  150.  
  151.     theErr = ReadLine(LN_LEN, rdBuffer);
  152.     inLine = rdBuffer;
  153.     funcVal = atof(inLine);
  154.     maxFunc = funcVal;
  155.     minFunc = funcVal;
  156.     xAtMax = startX;
  157.     yAtMax = startY;
  158.     xAtMin = startX;
  159.     yAtMin = startY;
  160.  
  161.     currX = startX;
  162.  
  163.     for (xCnt = 0; xCnt < numX; xCnt++)
  164.     {
  165.         currY = startY;
  166.         for (yCnt = 0; yCnt < numY; yCnt++)
  167.         {
  168.             funcVal = NextVal(&inLine);
  169.             funcResults[(long)xCnt * numY + (long)yCnt] = funcVal;
  170.             if (funcVal > maxFunc) {
  171.                 maxFunc = funcVal;
  172.                 xAtMax = currX;
  173.                 yAtMax = currY;
  174.             }
  175.             else if (funcVal < minFunc) {
  176.                 minFunc = funcVal;
  177.                 xAtMin = currX;
  178.                 yAtMin = currY;
  179.             }
  180.             currY += deltaY;
  181.         }
  182.         if (CmndPeriod())
  183.             break;  /* for */
  184.         currX += deltaX;
  185.         theErr = ReadLine(LN_LEN, rdBuffer);
  186.         inLine = rdBuffer;
  187.     }
  188.  
  189.     maxVect.x = xAtMax;
  190.     maxVect.y = yAtMax;
  191.     maxVect.z = maxFunc;
  192.     minVect.x = xAtMin;
  193.     minVect.y = yAtMin;
  194.     minVect.z = minFunc;
  195. }
  196.  
  197. static
  198. Real
  199. NextVal(str)
  200. unsigned    char    **str;
  201. {
  202.     Real    result, atof();
  203.  
  204.     result = atof(*str);
  205.  
  206.     while(NOT(isspace(**str)))
  207.         (*str)++;
  208.     while(isspace(**str))
  209.         (*str)++;
  210.  
  211.     return(result);
  212. }
  213.